using Google.ProtocolBuffers;
using Google.ProtocolBuffers.Collections;
using micromsg.Proto;
using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Runtime.CompilerServices;
namespace micromsg
{
	[GeneratedCode("ProtoGen", "2.3.0.277"), DebuggerNonUserCode, CompilerGenerated]
	public sealed class ThrowBottleResponse : GeneratedMessageLite<ThrowBottleResponse, ThrowBottleResponse.Builder>
	{
		[GeneratedCode("ProtoGen", "2.3.0.277"), DebuggerNonUserCode, CompilerGenerated]
		public sealed class Builder : GeneratedBuilderLite<ThrowBottleResponse, ThrowBottleResponse.Builder>
		{
			private bool resultIsReadOnly;
			private ThrowBottleResponse result;
			protected override ThrowBottleResponse.Builder ThisBuilder
			{
				get
				{
					return this;
				}
			}
			public override bool IsInitialized
			{
				get
				{
					return this.result.IsInitialized;
				}
			}
			protected override ThrowBottleResponse MessageBeingBuilt
			{
				get
				{
					return this.PrepareBuilder();
				}
			}
			public override ThrowBottleResponse DefaultInstanceForType
			{
				get
				{
					return ThrowBottleResponse.DefaultInstance;
				}
			}
			public BaseResponse BaseResponse
			{
				get
				{
					return this.result.BaseResponse;
				}
				set
				{
					this.SetBaseResponse(value);
				}
			}
			public int StartPos
			{
				get
				{
					return this.result.StartPos;
				}
				set
				{
					this.SetStartPos(value);
				}
			}
			public int TotalLen
			{
				get
				{
					return this.result.TotalLen;
				}
				set
				{
					this.SetTotalLen(value);
				}
			}
			public int ThrowCount
			{
				get
				{
					return this.result.ThrowCount;
				}
				set
				{
					this.SetThrowCount(value);
				}
			}
			public int PickCount
			{
				get
				{
					return this.result.PickCount;
				}
				set
				{
					this.SetPickCount(value);
				}
			}
			public int BottleListNum
			{
				get
				{
					return this.result.BottleListNum;
				}
				set
				{
					this.SetBottleListNum(value);
				}
			}
			public IPopsicleList<SKBuiltinString_t> BottleListList
			{
				get
				{
					return this.PrepareBuilder().bottleList_;
				}
			}
			public int BottleListCount
			{
				get
				{
					return this.result.BottleListCount;
				}
			}
			public int Distance
			{
				get
				{
					return this.result.Distance;
				}
				set
				{
					this.SetDistance(value);
				}
			}
			public Builder()
			{
				this.result = ThrowBottleResponse.DefaultInstance;
				this.resultIsReadOnly = true;
			}
			internal Builder(ThrowBottleResponse cloneFrom)
			{
				this.result = cloneFrom;
				this.resultIsReadOnly = true;
			}
			private ThrowBottleResponse PrepareBuilder()
			{
				if (this.resultIsReadOnly)
				{
					ThrowBottleResponse other = this.result;
					this.result = new ThrowBottleResponse();
					this.resultIsReadOnly = false;
					this.MergeFrom(other);
				}
				return this.result;
			}
			public override ThrowBottleResponse.Builder Clear()
			{
				this.result = ThrowBottleResponse.DefaultInstance;
				this.resultIsReadOnly = true;
				return this;
			}
			public override ThrowBottleResponse.Builder Clone()
			{
				if (this.resultIsReadOnly)
				{
					return new ThrowBottleResponse.Builder(this.result);
				}
				return new ThrowBottleResponse.Builder().MergeFrom(this.result);
			}
			public override ThrowBottleResponse BuildPartial()
			{
				if (this.resultIsReadOnly)
				{
					return this.result;
				}
				this.resultIsReadOnly = true;
				return this.result.MakeReadOnly();
			}
			public override ThrowBottleResponse.Builder MergeFrom(IMessageLite other)
			{
				if (other is ThrowBottleResponse)
				{
					return this.MergeFrom((ThrowBottleResponse)other);
				}
				base.MergeFrom(other);
				return this;
			}
			public override ThrowBottleResponse.Builder MergeFrom(ThrowBottleResponse other)
			{
				return this;
			}
			public override ThrowBottleResponse.Builder MergeFrom(ICodedInputStream input)
			{
				return this.MergeFrom(input, ExtensionRegistry.Empty);
			}
			public override ThrowBottleResponse.Builder MergeFrom(ICodedInputStream input, ExtensionRegistry extensionRegistry)
			{
				this.PrepareBuilder();
				uint num;
				string text;
				while (input.ReadTag(out num, out text))
				{
					if (num == 0u && text != null)
					{
						int num2 = Array.BinarySearch<string>(ThrowBottleResponse._throwBottleResponseFieldNames, text, StringComparer.get_Ordinal());
						if (num2 < 0)
						{
							this.ParseUnknownField(input, extensionRegistry, num, text);
							continue;
						}
						num = ThrowBottleResponse._throwBottleResponseFieldTags[num2];
					}
					uint num3 = num;
					if (num3 <= 24u)
					{
						if (num3 <= 10u)
						{
							if (num3 == 0u)
							{
								throw InvalidProtocolBufferException.InvalidTag();
							}
							if (num3 == 10u)
							{
								BaseResponse.Builder builder = BaseResponse.CreateBuilder();
								if (this.result.hasBaseResponse)
								{
									builder.MergeFrom(this.BaseResponse);
								}
								input.ReadMessage(builder, extensionRegistry);
								this.BaseResponse = builder.BuildPartial();
								continue;
							}
						}
						else
						{
							if (num3 == 16u)
							{
								this.result.hasStartPos = input.ReadInt32(ref this.result.startPos_);
								continue;
							}
							if (num3 == 24u)
							{
								this.result.hasTotalLen = input.ReadInt32(ref this.result.totalLen_);
								continue;
							}
						}
					}
					else
					{
						if (num3 <= 40u)
						{
							if (num3 == 32u)
							{
								this.result.hasThrowCount = input.ReadInt32(ref this.result.throwCount_);
								continue;
							}
							if (num3 == 40u)
							{
								this.result.hasPickCount = input.ReadInt32(ref this.result.pickCount_);
								continue;
							}
						}
						else
						{
							if (num3 == 48u)
							{
								this.result.hasBottleListNum = input.ReadInt32(ref this.result.bottleListNum_);
								continue;
							}
							if (num3 == 58u)
							{
								input.ReadMessageArray<SKBuiltinString_t>(num, text, this.result.bottleList_, SKBuiltinString_t.DefaultInstance, extensionRegistry);
								continue;
							}
							if (num3 == 64u)
							{
								this.result.hasDistance = input.ReadInt32(ref this.result.distance_);
								continue;
							}
						}
					}
					if (WireFormat.IsEndGroupTag(num))
					{
						return this;
					}
					this.ParseUnknownField(input, extensionRegistry, num, text);
				}
				return this;
			}
			public ThrowBottleResponse.Builder SetBaseResponse(BaseResponse value)
			{
				ThrowHelper.ThrowIfNull(value, "value");
				this.PrepareBuilder();
				this.result.hasBaseResponse = true;
				this.result.baseResponse_ = value;
				return this;
			}
			public ThrowBottleResponse.Builder SetBaseResponse(BaseResponse.Builder builderForValue)
			{
				ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
				this.PrepareBuilder();
				this.result.hasBaseResponse = true;
				this.result.baseResponse_ = builderForValue.Build();
				return this;
			}
			public ThrowBottleResponse.Builder MergeBaseResponse(BaseResponse value)
			{
				ThrowHelper.ThrowIfNull(value, "value");
				this.PrepareBuilder();
				if (this.result.hasBaseResponse && this.result.baseResponse_ != BaseResponse.DefaultInstance)
				{
					this.result.baseResponse_ = BaseResponse.CreateBuilder(this.result.baseResponse_).MergeFrom(value).BuildPartial();
				}
				else
				{
					this.result.baseResponse_ = value;
				}
				this.result.hasBaseResponse = true;
				return this;
			}
			public ThrowBottleResponse.Builder ClearBaseResponse()
			{
				this.PrepareBuilder();
				this.result.hasBaseResponse = false;
				this.result.baseResponse_ = null;
				return this;
			}
			public ThrowBottleResponse.Builder SetStartPos(int value)
			{
				this.PrepareBuilder();
				this.result.hasStartPos = true;
				this.result.startPos_ = value;
				return this;
			}
			public ThrowBottleResponse.Builder ClearStartPos()
			{
				this.PrepareBuilder();
				this.result.hasStartPos = false;
				this.result.startPos_ = 0;
				return this;
			}
			public ThrowBottleResponse.Builder SetTotalLen(int value)
			{
				this.PrepareBuilder();
				this.result.hasTotalLen = true;
				this.result.totalLen_ = value;
				return this;
			}
			public ThrowBottleResponse.Builder ClearTotalLen()
			{
				this.PrepareBuilder();
				this.result.hasTotalLen = false;
				this.result.totalLen_ = 0;
				return this;
			}
			public ThrowBottleResponse.Builder SetThrowCount(int value)
			{
				this.PrepareBuilder();
				this.result.hasThrowCount = true;
				this.result.throwCount_ = value;
				return this;
			}
			public ThrowBottleResponse.Builder ClearThrowCount()
			{
				this.PrepareBuilder();
				this.result.hasThrowCount = false;
				this.result.throwCount_ = 0;
				return this;
			}
			public ThrowBottleResponse.Builder SetPickCount(int value)
			{
				this.PrepareBuilder();
				this.result.hasPickCount = true;
				this.result.pickCount_ = value;
				return this;
			}
			public ThrowBottleResponse.Builder ClearPickCount()
			{
				this.PrepareBuilder();
				this.result.hasPickCount = false;
				this.result.pickCount_ = 0;
				return this;
			}
			public ThrowBottleResponse.Builder SetBottleListNum(int value)
			{
				this.PrepareBuilder();
				this.result.hasBottleListNum = true;
				this.result.bottleListNum_ = value;
				return this;
			}
			public ThrowBottleResponse.Builder ClearBottleListNum()
			{
				this.PrepareBuilder();
				this.result.hasBottleListNum = false;
				this.result.bottleListNum_ = 0;
				return this;
			}
			public SKBuiltinString_t GetBottleList(int index)
			{
				return this.result.GetBottleList(index);
			}
			public ThrowBottleResponse.Builder SetBottleList(int index, SKBuiltinString_t value)
			{
				ThrowHelper.ThrowIfNull(value, "value");
				this.PrepareBuilder();
				this.result.bottleList_[index] = value;
				return this;
			}
			public ThrowBottleResponse.Builder SetBottleList(int index, SKBuiltinString_t.Builder builderForValue)
			{
				ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
				this.PrepareBuilder();
				this.result.bottleList_[index] = builderForValue.Build();
				return this;
			}
			public ThrowBottleResponse.Builder AddBottleList(SKBuiltinString_t value)
			{
				ThrowHelper.ThrowIfNull(value, "value");
				this.PrepareBuilder();
				this.result.bottleList_.Add(value);
				return this;
			}
			public ThrowBottleResponse.Builder AddBottleList(SKBuiltinString_t.Builder builderForValue)
			{
				ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
				this.PrepareBuilder();
				this.result.bottleList_.Add(builderForValue.Build());
				return this;
			}
			public ThrowBottleResponse.Builder AddRangeBottleList(IEnumerable<SKBuiltinString_t> values)
			{
				this.PrepareBuilder();
				this.result.bottleList_.Add(values);
				return this;
			}
			public ThrowBottleResponse.Builder ClearBottleList()
			{
				this.PrepareBuilder();
				this.result.bottleList_.Clear();
				return this;
			}
			public ThrowBottleResponse.Builder SetDistance(int value)
			{
				this.PrepareBuilder();
				this.result.hasDistance = true;
				this.result.distance_ = value;
				return this;
			}
			public ThrowBottleResponse.Builder ClearDistance()
			{
				this.PrepareBuilder();
				this.result.hasDistance = false;
				this.result.distance_ = 0;
				return this;
			}
		}
		public const int BaseResponseFieldNumber = 1;
		public const int StartPosFieldNumber = 2;
		public const int TotalLenFieldNumber = 3;
		public const int ThrowCountFieldNumber = 4;
		public const int PickCountFieldNumber = 5;
		public const int BottleListNumFieldNumber = 6;
		public const int BottleListFieldNumber = 7;
		public const int DistanceFieldNumber = 8;
		private static readonly ThrowBottleResponse defaultInstance;
		private static readonly string[] _throwBottleResponseFieldNames;
		private static readonly uint[] _throwBottleResponseFieldTags;
		private bool hasBaseResponse;
		private BaseResponse baseResponse_;
		private bool hasStartPos;
		private int startPos_;
		private bool hasTotalLen;
		private int totalLen_;
		private bool hasThrowCount;
		private int throwCount_;
		private bool hasPickCount;
		private int pickCount_;
		private bool hasBottleListNum;
		private int bottleListNum_;
		private PopsicleList<SKBuiltinString_t> bottleList_ = new PopsicleList<SKBuiltinString_t>();
		private bool hasDistance;
		private int distance_;
		private int memoizedSerializedSize = -1;
		public static ThrowBottleResponse DefaultInstance
		{
			get
			{
				return ThrowBottleResponse.defaultInstance;
			}
		}
		public override ThrowBottleResponse DefaultInstanceForType
		{
			get
			{
				return ThrowBottleResponse.DefaultInstance;
			}
		}
		protected override ThrowBottleResponse ThisMessage
		{
			get
			{
				return this;
			}
		}
		public BaseResponse BaseResponse
		{
			get
			{
				return this.baseResponse_ ?? BaseResponse.DefaultInstance;
			}
		}
		public int StartPos
		{
			get
			{
				return this.startPos_;
			}
		}
		public int TotalLen
		{
			get
			{
				return this.totalLen_;
			}
		}
		public int ThrowCount
		{
			get
			{
				return this.throwCount_;
			}
		}
		public int PickCount
		{
			get
			{
				return this.pickCount_;
			}
		}
		public int BottleListNum
		{
			get
			{
				return this.bottleListNum_;
			}
		}
		public IList<SKBuiltinString_t> BottleListList
		{
			get
			{
				return this.bottleList_;
			}
		}
		public int BottleListCount
		{
			get
			{
				return this.bottleList_.Count;
			}
		}
		public int Distance
		{
			get
			{
				return this.distance_;
			}
		}
		public override bool IsInitialized
		{
			get
			{
				return this.hasBaseResponse && this.hasStartPos && this.hasTotalLen && this.hasThrowCount && this.hasPickCount && this.hasBottleListNum && this.hasDistance && this.BaseResponse.IsInitialized;
			}
		}
		public override int SerializedSize
		{
			get
			{
				int num = this.memoizedSerializedSize;
				if (num != -1)
				{
					return num;
				}
				num = 0;
				if (this.hasBaseResponse)
				{
					num += CodedOutputStream.ComputeMessageSize(1, this.BaseResponse);
				}
				if (this.hasStartPos)
				{
					num += CodedOutputStream.ComputeInt32Size(2, this.StartPos);
				}
				if (this.hasTotalLen)
				{
					num += CodedOutputStream.ComputeInt32Size(3, this.TotalLen);
				}
				if (this.hasThrowCount)
				{
					num += CodedOutputStream.ComputeInt32Size(4, this.ThrowCount);
				}
				if (this.hasPickCount)
				{
					num += CodedOutputStream.ComputeInt32Size(5, this.PickCount);
				}
				if (this.hasBottleListNum)
				{
					num += CodedOutputStream.ComputeInt32Size(6, this.BottleListNum);
				}
				using (IEnumerator<SKBuiltinString_t> enumerator = this.BottleListList.GetEnumerator())
				{
					while (enumerator.MoveNext())
					{
						SKBuiltinString_t current = enumerator.get_Current();
						num += CodedOutputStream.ComputeMessageSize(7, current);
					}
				}
				if (this.hasDistance)
				{
					num += CodedOutputStream.ComputeInt32Size(8, this.Distance);
				}
				this.memoizedSerializedSize = num;
				return num;
			}
		}
		private ThrowBottleResponse()
		{
		}
		public SKBuiltinString_t GetBottleList(int index)
		{
			return this.bottleList_[index];
		}
		public override void WriteTo(ICodedOutputStream output)
		{
			int arg_06_0 = this.SerializedSize;
			string[] throwBottleResponseFieldNames = ThrowBottleResponse._throwBottleResponseFieldNames;
			if (this.hasBaseResponse)
			{
				output.WriteMessage(1, throwBottleResponseFieldNames[0], this.BaseResponse);
			}
			if (this.hasStartPos)
			{
				output.WriteInt32(2, throwBottleResponseFieldNames[5], this.StartPos);
			}
			if (this.hasTotalLen)
			{
				output.WriteInt32(3, throwBottleResponseFieldNames[7], this.TotalLen);
			}
			if (this.hasThrowCount)
			{
				output.WriteInt32(4, throwBottleResponseFieldNames[6], this.ThrowCount);
			}
			if (this.hasPickCount)
			{
				output.WriteInt32(5, throwBottleResponseFieldNames[4], this.PickCount);
			}
			if (this.hasBottleListNum)
			{
				output.WriteInt32(6, throwBottleResponseFieldNames[2], this.BottleListNum);
			}
			if (this.bottleList_.Count > 0)
			{
				output.WriteMessageArray<SKBuiltinString_t>(7, throwBottleResponseFieldNames[1], this.bottleList_);
			}
			if (this.hasDistance)
			{
				output.WriteInt32(8, throwBottleResponseFieldNames[3], this.Distance);
			}
		}
		public override int GetHashCode()
		{
			int num = base.GetType().GetHashCode();
			if (this.hasBaseResponse)
			{
				num ^= this.baseResponse_.GetHashCode();
			}
			if (this.hasStartPos)
			{
				num ^= this.startPos_.GetHashCode();
			}
			if (this.hasTotalLen)
			{
				num ^= this.totalLen_.GetHashCode();
			}
			if (this.hasThrowCount)
			{
				num ^= this.throwCount_.GetHashCode();
			}
			if (this.hasPickCount)
			{
				num ^= this.pickCount_.GetHashCode();
			}
			if (this.hasBottleListNum)
			{
				num ^= this.bottleListNum_.GetHashCode();
			}
			using (IEnumerator<SKBuiltinString_t> enumerator = this.bottleList_.GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					SKBuiltinString_t current = enumerator.get_Current();
					num ^= current.GetHashCode();
				}
			}
			if (this.hasDistance)
			{
				num ^= this.distance_.GetHashCode();
			}
			return num;
		}
		public override bool Equals(object object_0)
		{
			ThrowBottleResponse throwBottleResponse = object_0 as ThrowBottleResponse;
			if (throwBottleResponse == null)
			{
				return false;
			}
			if (this.hasBaseResponse != throwBottleResponse.hasBaseResponse || (this.hasBaseResponse && !this.baseResponse_.Equals(throwBottleResponse.baseResponse_)))
			{
				return false;
			}
			if (this.hasStartPos != throwBottleResponse.hasStartPos || (this.hasStartPos && !this.startPos_.Equals(throwBottleResponse.startPos_)))
			{
				return false;
			}
			if (this.hasTotalLen != throwBottleResponse.hasTotalLen || (this.hasTotalLen && !this.totalLen_.Equals(throwBottleResponse.totalLen_)))
			{
				return false;
			}
			if (this.hasThrowCount != throwBottleResponse.hasThrowCount || (this.hasThrowCount && !this.throwCount_.Equals(throwBottleResponse.throwCount_)))
			{
				return false;
			}
			if (this.hasPickCount != throwBottleResponse.hasPickCount || (this.hasPickCount && !this.pickCount_.Equals(throwBottleResponse.pickCount_)))
			{
				return false;
			}
			if (this.hasBottleListNum != throwBottleResponse.hasBottleListNum || (this.hasBottleListNum && !this.bottleListNum_.Equals(throwBottleResponse.bottleListNum_)))
			{
				return false;
			}
			if (this.bottleList_.Count != throwBottleResponse.bottleList_.Count)
			{
				return false;
			}
			for (int i = 0; i < this.bottleList_.Count; i++)
			{
				if (!this.bottleList_[i].Equals(throwBottleResponse.bottleList_[i]))
				{
					return false;
				}
			}
			return this.hasDistance == throwBottleResponse.hasDistance && (!this.hasDistance || this.distance_.Equals(throwBottleResponse.distance_));
		}
		public override void PrintTo(TextWriter writer)
		{
			GeneratedMessageLite<ThrowBottleResponse, ThrowBottleResponse.Builder>.PrintField("BaseResponse", this.hasBaseResponse, this.baseResponse_, writer);
			GeneratedMessageLite<ThrowBottleResponse, ThrowBottleResponse.Builder>.PrintField("StartPos", this.hasStartPos, this.startPos_, writer);
			GeneratedMessageLite<ThrowBottleResponse, ThrowBottleResponse.Builder>.PrintField("TotalLen", this.hasTotalLen, this.totalLen_, writer);
			GeneratedMessageLite<ThrowBottleResponse, ThrowBottleResponse.Builder>.PrintField("ThrowCount", this.hasThrowCount, this.throwCount_, writer);
			GeneratedMessageLite<ThrowBottleResponse, ThrowBottleResponse.Builder>.PrintField("PickCount", this.hasPickCount, this.pickCount_, writer);
			GeneratedMessageLite<ThrowBottleResponse, ThrowBottleResponse.Builder>.PrintField("BottleListNum", this.hasBottleListNum, this.bottleListNum_, writer);
			GeneratedMessageLite<ThrowBottleResponse, ThrowBottleResponse.Builder>.PrintField<SKBuiltinString_t>("BottleList", this.bottleList_, writer);
			GeneratedMessageLite<ThrowBottleResponse, ThrowBottleResponse.Builder>.PrintField("Distance", this.hasDistance, this.distance_, writer);
		}
		public static ThrowBottleResponse ParseFrom(byte[] data)
		{
			return ThrowBottleResponse.CreateBuilder().MergeFrom(data).BuildParsed();
		}
		private ThrowBottleResponse MakeReadOnly()
		{
			this.bottleList_.MakeReadOnly();
			return this;
		}
		public static ThrowBottleResponse.Builder CreateBuilder()
		{
			return new ThrowBottleResponse.Builder();
		}
		public override ThrowBottleResponse.Builder ToBuilder()
		{
			return ThrowBottleResponse.CreateBuilder(this);
		}
		public override ThrowBottleResponse.Builder CreateBuilderForType()
		{
			return new ThrowBottleResponse.Builder();
		}
		public static ThrowBottleResponse.Builder CreateBuilder(ThrowBottleResponse prototype)
		{
			return new ThrowBottleResponse.Builder(prototype);
		}
		static ThrowBottleResponse()
		{
			ThrowBottleResponse.defaultInstance = new ThrowBottleResponse().MakeReadOnly();
			ThrowBottleResponse._throwBottleResponseFieldNames = new string[]
			{
				"BaseResponse",
				"BottleList",
				"BottleListNum",
				"Distance",
				"PickCount",
				"StartPos",
				"ThrowCount",
				"TotalLen"
			};
			ThrowBottleResponse._throwBottleResponseFieldTags = new uint[]
			{
				10u,
				58u,
				48u,
				64u,
				40u,
				16u,
				32u,
				24u
			};
			object.ReferenceEquals(micromsg.Proto.ThrowBottleResponse.Descriptor, null);
		}
	}
}
